// 有3种状态、状态一旦改变就不会再改变回去。
const FULLFILLED = "fulfilled";
const REJECTED = "rejected";
const PENDING = "pending";

// 设置微任务
function setMicroTask(callback) {
    setTimeout(callback);
}

// 定义一个 promise 对象
function MyPromise(executor) {
    // promise 状态
    this.state = PENDING;
    // promise 返回值
    this.value = null;
    // then 方法中的函数队列
    this.callbackQueue = [];
    // 保存 this
    const self = this;

    // 设置 promise 状态和返回值
    function setState(state, value) {
        if (self.state !== PENDING) return;
        self.state = state;
        self.value = value;
        // promise 状态变更后，异步处理 then 函数中的回调（根据状态判断，执行哪个回调）
        // 异步处理的原因是：promise 构造函数初始化逻辑可能是异步的，而 then 函数回调处理必须要等状态改变之后才能执行
        // 哪怕 promise 构造函数初始化逻辑是异步套异步套娃形式的，只要状态未变更之前，都不会执行 then 函数回调
        setMicroTask(() => {
            self.callbackQueue.forEach(item => {
                self.state === FULLFILLED ? item.onResolved() : item.onRejected();
            });
        });
    }
    // resolve 函数参数
    function resolve(data) {
        setState(FULLFILLED, data);
    }
    // reject 函数参数
    function reject(error) {
        setState(REJECTED, error);
    }
    // promise 构造函数初始化：执行传入的函数
    try {
        executor(resolve, reject);
    } catch (error) {
        reject(error);
    }
}

// promise then 静态方法
MyPromise.prototype.then = function(onResolved, onRejected) {
    // 保存 this 
    const self = this;

    return new MyPromise(function(resolve, reject) {
        // then 方法 onResolved、onRejected 参数不为函数时处理
        if (typeof onResolved !== "function") {
            onResolved = value => value;
        }
        if (typeof onRejected !== "function") {
            onRejected = error => {
                throw error;
            }
        }
        // then 方法 onResolved、onRejected 函数参数执行之后可能是 promise 需要判断处理
        function callback(type) {
            try {
                const result = type(self.value);
                // 是 promise 执行对应的 then 方法
                if (result instanceof MyPromise) {
                    result.then(value => {
                        resolve(value);
                    }, (error) => {
                        reject(error);
                    })
                } else {
                    resolve(result);
                }
            } catch (error) {
                reject(error);
            }
        }
        // 执行 then 方法时，根据 promsie 状态执行对应的回调
        if (self.state === FULLFILLED) {
            setMicroTask(() => {
                callback(onResolved);
            });
        }
        if (self.state === REJECTED) {
            setMicroTask(() => {
                callback(onRejected);
            });
        }
        // 执行 then方法时，如果还是 pending 状态，收集回调函数到函数队列里，以便状态变更时拿出来继续执行
        if (self.state === PENDING) {
            self.callbackQueue.push({
                onResolved: () => {
                    callback(onResolved);
                },
                onRejected: () => {
                    callback(onRejected);
                }
            });
        }
    })
}


// 测试验证
const p = new Promise((resolve, reject) => {
    console.log('001-初始化-异步方法之前');
    setTimeout(() => {
        console.log('003-初始化-异步之后-resolve之前');
        resolve('ok');
        console.log('004-初始化-异步之后-resolve之后');
    });
    console.log('002-初始化-异步方法之后');
}).then((value) => {
    return new Promise((resolve, reject) => {
        console.log('005-then resolve方法执行--返回promise', value);
        resolve('promise value: ' + value)
    })
}).then((value) => {
    console.log('006-then resolve方法执行', value);
})